//package br.odb.bzk3.android;
//
//import java.nio.Buffer;
//import java.nio.ByteBuffer;
//import java.nio.ByteOrder;
//import java.nio.FloatBuffer;
//import java.util.ArrayList;
//
//import javax.microedition.khronos.egl.EGLConfig;
//import javax.microedition.khronos.opengles.GL10;
//
//import br.odb.bzk3.geometry.Actor;
//
//import android.opengl.GLES20;
//import android.opengl.GLSurfaceView;
//import android.opengl.GLU;
//import android.opengl.Matrix;
//import android.os.SystemClock;
//
//public class GLES2Renderer implements GLSurfaceView.Renderer {
//	private int mProgram;
//	private int maPositionHandle;
//	private int colorHandle;
//	  private int muMVPMatrixHandle;
//	    private float[] mMVPMatrix = new float[16];
//	    private float[] mMMatrix = new float[16];
//	    private float[] mVMatrix = new float[16];
//	    private float[] mProjMatrix = new float[16];
//	    
//	    private final String vertexShaderCode = 
//	        // This matrix member variable provides a hook to manipulate
//	        // the coordinates of the objects that use this vertex shader
//	        "uniform mat4 uMVPMatrix;   \n" +
//	        
//	        "attribute vec4 vPosition;  \n" +
//	        "attribute vec4 a_color;  \n" +
//	        "varying vec4 v_color;  \n" +
//	        "void main(){               \n" +
//	        "v_color = vec4 (a_color.r, a_color.g, a_color.b, a_color.a);\n"+
//	        // the matrix must be included as a modifier of gl_Position
//	        " gl_Position = uMVPMatrix * vPosition; \n" +
//	        
//	        "}  \n";
//	    
//	    private final String fragmentShaderCode = 
//	        "precision mediump float;  \n" +
//	        "varying vec4 v_color;\n" +
//	        "void main(){              \n" +	 
//	        "gl_FragColor = vec4( v_color.x, v_color.y, v_color.z, 1.0 ); \n" +
//	        "}                         \n";
//
//	private ArrayList<Sector> sectorsToRender;
//	private ArrayList<Square> squaresToRender;
//	private ArrayList<Actor> actors;
//	public ArrayList<Triangle> shapes;
//	private float angle;
//	public Actor cameraActor;
//	private String displayList;
//	float[] squareColors = new float[4];
//	
//	public void onSurfaceCreated(GL10 unused, EGLConfig config) {
//
//		// Set the background frame color
//		GLES20.glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
//		 initShapes();
//		// initialize the triangle vertex array
//		int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
//		int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER,
//				fragmentShaderCode);
//
//		mProgram = GLES20.glCreateProgram(); // create empty OpenGL Program
//		GLES20.glAttachShader(mProgram, vertexShader); // add the vertex shader
//														// to program
//		GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment
//															// shader to program
//		GLES20.glLinkProgram(mProgram); // creates OpenGL program executables
//
//		// get handle to the vertex shader's vPosition member
//		maPositionHandle = GLES20.glGetAttribLocation( mProgram, "vPosition" );
//		colorHandle = GLES20.glGetAttribLocation( mProgram, "a_color" );
//	}
//
//	private int loadShader(int type, String shaderCode) {
//
//		// create a vertex shader type (GLES20.GL_VERTEX_SHADER)
//		// or a fragment shader type (GLES20.GL_FRAGMENT_SHADER)
//		int shader = GLES20.glCreateShader(type);
//
//		// add the source code to the shader and compile it
//		GLES20.glShaderSource(shader, shaderCode);
//		GLES20.glCompileShader(shader);
//
//		return shader;
//	}
//
//	public void onDrawFrame(GL10 unused) {
//		GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
//
//		setCamera(unused);
//		
//		
//		if (EngineView20.loaded)
//			// return;
//
//			synchronized (this) {
//				// Redraw background color
//
//
//				// Log.d("BZK3", "camera: " + cameraActor.iStartPoint.toString()
//				// );
//				// for (int c = 0; c < lightEmissors.size(); c++)
//				// if (lightEmissors.get(c).candelas > 0)
//				// lit(lightEmissors.get(c).Sector-1,
//				// lightEmissors.get(c).candelas);
//
//				for (int c = 0; c < this.sectorsToRender.size(); c++) {
//					((Sector) this.sectorsToRender.get(c)).lit();
//				}
//
//				this.renderScene(unused);		
//
//				for (int c = 0; c < this.sectorsToRender.size(); c++) {
//					((Sector) this.sectorsToRender.get(c)).reset();
//				}
//			}
//
//	}
//
//	private void setCamera(GL10 unused) {
////        long time = SystemClock.uptimeMillis() % 4000L;
////        float angle = 0.090f * ((int) time);
////        Matrix.setRotateM(mMMatrix, 0, angle, 0, 0, 1.0f);
//        Matrix.multiplyMM(mMVPMatrix, 0, mVMatrix, 0, mMMatrix, 0);
//        Matrix.multiplyMM(mMVPMatrix, 0, mProjMatrix, 0, mMVPMatrix, 0);
//        
//        // Apply a ModelView Projection transformation
//        GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, mMVPMatrix, 0);
//        
//        Matrix.multiplyMM(mMVPMatrix, 0, mProjMatrix, 0, mVMatrix, 0);
//        GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, mMVPMatrix, 0);
//	}
//
//	private void renderScene(GL10 unused) {
//		// Add program to OpenGL environment
//		GLES20.glUseProgram(mProgram);
//		
//		Square square;
//		Triangle t;
//		GLES20.glEnable(GL10.GL_DEPTH_TEST);
//		
//        // Prepare the triangle data
//        		
//		for (int c = 0; c < this.squaresToRender.size(); c++) {
//			square = ((Square) this.squaresToRender.get(c));
//
//			// unused.glColor4f(square.getColor(0), square.getColor(1), square.getColor(2), square.getColor(3) );
//			//			 square.draw( unused );
//			square.drawGLES2( maPositionHandle, colorHandle );
//			
//		}
//		Actor actor;
//		ObjMesh trigs;
//		Triangle trig;
//		for (int c = 1; c < this.actors.size(); ++c) {
//			actor = actors.get(c);
//			trigs = actor.getMesh();
//			// unused.glTranslatef( actor.iStartPoint.iX, actor.iStartPoint.iY,
//			// actor.iStartPoint.iZ );
//
//			for (int d = 0; d < trigs.getMesh().size(); ++d) {
//				trig = (Triangle) trigs.getMesh().elementAt(d);
////				 trig.draw( unused );
//				trig.drawGLES2( maPositionHandle, colorHandle );
//			}
//			// unused.glTranslatef( -actor.iStartPoint.iX,
//			// -actor.iStartPoint.iY, -actor.iStartPoint.iZ );
//		}
//
//		GLES20.glDisable(GL10.GL_DEPTH_TEST);
//		// unused.glLoadIdentity();
//		for (int c = 0; c < shapes.size(); ++c) {
//			t = shapes.get(c);
//			t.drawGLES2( maPositionHandle, colorHandle );
////			 t.draw(unused);
//		}
//	}
//
//    public void onSurfaceChanged(GL10 unused, int width, int height) {
//        GLES20.glViewport(0, 0, width, height);
//        
//        float ratio = (float) width / height;
//        
//        // this projection matrix is applied to object coodinates
//        // in the onDrawFrame() method
//        Matrix.frustumM(mProjMatrix, 0, -ratio, ratio, -1, 1, 1, 255 );        
//        muMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
//        Matrix.setLookAtM(mVMatrix, 0, 0, 0, -3, 0f, 0f, 0f, 0f, 1.0f, 0.0f);        
//    }  
//
//
//	// ------------------------------------------------------------------------------------------------------------
//	public String toString() {
//		return displayList;
//	}
//	  private FloatBuffer triangleVB;
//	  private void initShapes(){
//		    
//	        float triangleCoords[] = {
//	            // X, Y, Z
//	            -0.5f, -0.25f, 0,
//	             0.5f, -0.25f, 0,
//	             0.0f,  0.559016994f, 0
//	        }; 
//	        
//	        // initialize vertex Buffer for triangle  
//	        ByteBuffer vbb = ByteBuffer.allocateDirect(
//	                // (# of coordinate values * 4 bytes per float)
//	                triangleCoords.length * 4); 
//	        vbb.order(ByteOrder.nativeOrder());// use the device hardware's native byte order
//	        triangleVB = vbb.asFloatBuffer();  // create a floating point buffer from the ByteBuffer
//	        triangleVB.put(triangleCoords);    // add the coordinates to the FloatBuffer
//	        triangleVB.position(0);            // set the buffer to read the first coordinate
//	    
//	    }
//	// ------------------------------------------------------------------------------------------------------------
//	public void addToScene(Sector sector) {
//		sectorsToRender.add(sector);
//	}
//
//	// ------------------------------------------------------------------------------------------------------------
//	public GLES2Renderer() {
//		sectorsToRender = new ArrayList<Sector>();
//		squaresToRender = new ArrayList<Square>();
//		actors = new ArrayList<Actor>();
//		shapes = new ArrayList<Triangle>();
//	}
//
//	// ------------------------------------------------------------------------------------------------------------
//	public void setAngle(float Angle) {
//		angle = Angle;
//	}
//
//	// ------------------------------------------------------------------------------------------------------------a
//
//	public void addToScene(Actor actor) {
//		actors.add(actor);
//	}
//
//	private void lit(int sector, int candelas) {
//		Sector sec = (Sector) this.sectorsToRender.get(sector);
//
//		float factor = (candelas) - 5.0f;
//
//		sec.candelas += factor;
//
//		if (sec.candelas >= 255) {
//			sec.candelas = 254;
//		}
//
//		factor -= sec.VisibleFaces * 5.0f;
//
//		if (factor < 8) {
//			return;
//		}
//
//		for (int c = 0; c < 6; c++) {
//			if (sec.GetLink(c) != 0) {
//				lit(sec.GetLink(c) - 1, (int) factor);
//			}
//		}
//
//	}
//	
//	
//
//
//	// ------------------------------------------------------------------------------------------------------------
//	public void buildScene() {
//		displayList = new String("");
//		Square square;
//		Sector sector;
//		// /master sector ja ficou de fora no momento em que não fui
//		// addToScene'ed
//		for (int c = 0; c < this.sectorsToRender.size(); c++) {
//
//			sector = sectorsToRender.get(c);
//
//			for (int d = 0; d < 6; d++)
//				if (sector.GetLink(d) == 0) {
//
//					square = null;
//
//					switch (d) {
//					case 0:
//						square = SquareFactory.MakeXY(sector.getX0(),
//								sector.getY0(), sector.getX1(), sector.getY1(),
//								sector.getZ0(), 0);
//						break;
//					case 2:
//						square = SquareFactory.MakeXY(sector.getX0(),
//								sector.getY0(), sector.getX1(), sector.getY1(),
//								sector.getZ1(), 0);
//						break;
//					case 1:
//						square = SquareFactory.MakeYZ(sector.getY0(),
//								sector.getZ0(), sector.getY1(), sector.getZ1(),
//								sector.getX0(), 0);
//						break;
//					case 3:
//						square = SquareFactory.MakeYZ(sector.getY0(),
//								sector.getZ0(), sector.getY1(), sector.getZ1(),
//								sector.getX1(), 0);
//						break;
//					case 4:
//						square = SquareFactory.MakeXZ(sector.getX0(),
//								sector.getZ0(), sector.getX1(), sector.getZ1(),
//								sector.getY0(), 0);
//						break;
//					case 5:
//						square = SquareFactory.MakeXZ(sector.getX0(),
//								sector.getZ0(), sector.getX1(), sector.getZ1(),
//								sector.getY1(), 0);
//						break;
//					}
//					square.setColor(sector.getColor(d).r / 255.0f,
//							sector.getColor(d).g / 255.0f,
//							sector.getColor(d).b / 255.0f, 1.0f);
//					sector.iFaces[d] = square;
//					this.squaresToRender.add(square);
//				}
//
//		}
//	}
//}
